from datetime import datetime

from flask_sqlalchemy import SQLAlchemy

from utils.constants import *

db=SQLAlchemy()

# 用户表
class User(db.Model):
    __tablename__="accounts_user"

    id=db.Column(db.Integer,primary_key=True,autoincrement=True) # 用户ID
    username=db.Column(db.VARCHAR(128),nullable=False,unique=True) # 用户名 唯一
    nickname=db.Column(db.VARCHAR(32)) # 用户昵称
    password=db.Column(db.VARCHAR(1024),nullable=False)
    avatar=db.Column(db.VARCHAR(64)) # 用户头像 头像地址
    status=db.Column(db.SmallInteger,default=UserStatus.USER_ACTIVE.value,comment='用户状态  1是正常，0是异常')  # 用户状态  1是正常，0是异常
    is_super=db.Column(db.SmallInteger,default=UserRole.COMMON.value,comment='是否超级管理员  1是超级管理员，0是普通管理') # 是否超级管理员  1是超级管理员，0是普通管理
    created_at=db.Column(db.DateTime,default=datetime.now())   # 注册时间
    updated_at=db.Column(db.DateTime,default=datetime.now(),onupdate=datetime.now())   # 更新时间

    @property
    def is_authenticated(self):
        """ 一个用来表示用户是否通过登录认证的属性 """
        return True

    @property
    def is_active(self):
        """ 有效的用户才能登录系统"""
        return self.status==UserStatus.USER_ACTIVE.value

    @property
    def is_anonymous(self):
        """ 常规用户的该属性是False，对特定的匿名用户是True。 """
        return False

    def get_id(self):
        return f'{self.id}'



# 用户详细信息表
class UserInfo(db.Model):
    __tablename__="account_user_profile"

    id=db.Column(db.Integer,primary_key=True,autoincrement=True)
    # 建立外键关系
    user_id=db.Column(db.Integer,db.ForeignKey('accounts_user.id'))
    username=db.Column(db.VARCHAR(32),nullable=False,unique=True)  # 冗余字段
    real_name=db.Column(db.VARCHAR(32)) # 真实姓名
    sex=db.Column(db.VARCHAR(32))
    maxim=db.Column(db.VARCHAR(128))   # 用户格言
    address=db.Column(db.VARCHAR(128))
    created_at=db.Column(db.DateTime,default=datetime.now())
    updated_at=db.Column(db.DateTime,default=datetime.now(),onupdate=datetime.now())
    # 建立关联关系，建立一对一的关系，相当于user.profile 访问User表，profile.user访问UserInfo表
    # backref 是双向绑定的意思
    user=db.relationship('User',backref=db.backref('profile',uselist=False))



# 登录的历史记录
class UserLoginHistory(db.Model):
    __tablename__ = "account_user_history"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
    username = db.Column(db.VARCHAR(32),nullable=False)
    login_type = db.Column(db.VARCHAR(32), nullable=False)
    ip = db.Column(db.VARCHAR(128))
    ua = db.Column(db.VARCHAR(128))
    created_at=db.Column(db.DateTime,default=datetime.now())
    # 双向绑定
    user=db.relationship('User',backref=db.backref('login_history',uselist=False))

# 第三方登录账号绑定
class UserThird(db.Model):
    __tablename__ = "account_third"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
    login_name=db.Column(db.VARCHAR(32),nullable=False)
    is_valid=db.Column(db.SmallInteger,default=UserStatus.USER_ACTIVE.value)
    created_at = db.Column(db.DateTime, default=datetime.now())
    updated_at = db.Column(db.DateTime, default=datetime.now(), onupdate=datetime.now())
    # 建立一对多的关系
    user=db.relationship('User',backref=db.backref('login_third',lazy='dynamic'))



# 问题
class Question(db.Model):
    __tablename__ = "qa_question"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    user_id=db.Column(db.Integer,db.ForeignKey("accounts_user.id"))
    title=db.Column(db.VARCHAR(128),nullable=False)
    desc=db.Column(db.VARCHAR(128),nullable=False)
    img=db.Column(db.VARCHAR(128),nullable=False)  # 估计是图片的base64
    content=db.Column(db.VARCHAR(128),nullable=False) # 内容
    reorder=db.Column(db.SmallInteger,default=True) # 是否排序
    # 逻辑删除
    is_valid=db.Column(db.Boolean,default=True) # 是否有效，1是有效，0是无效
    view_count=db.Column(db.Integer,default=0) # 浏览次数
    created_at = db.Column(db.DateTime, default=datetime.now())
    updated_at = db.Column(db.DateTime, default=datetime.now(), onupdate=datetime.now())
    # 建立一对多的关系
    user=db.relationship('User',backref=db.backref('question_list',lazy="dynamic"))

    @property
    # 获取问题的评论的数量
    def comment_count(self):
        # 关联到问题的评论的双向绑定，然后拿到有效的评论，再统计数量
        count=self.question_comment_list.filter_by(is_valid=True).count()
        return count

    @property
    # 问题的关注人有多少
    def question_follow(self):
        return self.question_follow_list.filter_by(is_valid=True).count()

    @property
    # 问题回答的数量
    def answer_count(self):
        return self.answer_list.filter_by(is_valid=True).count()

    @property
    def get_img_url(self):
        return 'medias/'+self.img if self.img else ''


# 问题的回答
class Answer(db.Model):
    __tablename__ = "qa_answer"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    user_id=db.Column(db.Integer,db.ForeignKey('accounts_user.id'))
    q_id=db.Column(db.Integer,db.ForeignKey('qa_question.id'))
    content=db.Column(db.VARCHAR(128),nullable=False) # 内容
    # 逻辑删除
    is_valid = db.Column(db.Boolean, default=False)  # 是否有效，1是有效，0是无效
    created_at = db.Column(db.DateTime, default=datetime.now())
    updated_at = db.Column(db.DateTime, default=datetime.now(), onupdate=datetime.now())
    # 建立一对多的关系,一个用户可以有多个回答，一个问题可以有多个回答
    question=db.relationship('Question',backref=db.backref('answer_list',lazy='dynamic'))
    user=db.relationship('User',backref=db.backref('answer_list',lazy='dynamic'))

    @property
    # 问题点赞的次数
    def answer_love(self):
        return self.answer_love_list.count()

    @property
    # 问题评论数
    def answer_comment_count(self):
        return self.answer_comment_list.filter_by(is_valid=True).count()





# 回答的评论
class AnswerComment(db.Model):
    __tablename__ = "qa_answer_comment"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id')) # 管理
    replay_id=db.Column(db.Integer,db.ForeignKey('qa_answer_comment.id')) # 关联评论？？？
    q_id=db.Column(db.Integer,db.ForeignKey('qa_question.id'))  # 关联问题
    answer_id = db.Column(db.Integer, db.ForeignKey('qa_answer.id'))  # 关联回答
    content = db.Column(db.VARCHAR(128), nullable=False)  # 内容
    love_count=db.Column(db.Integer,default=0) # 点赞数
    is_valid=db.Column(db.Boolean,default=True)
    is_public=db.Column(db.Boolean,default=True) # 是否公开
    created_at = db.Column(db.DateTime, default=datetime.now())
    updated_at = db.Column(db.DateTime, default=datetime.now(), onupdate=datetime.now())
    # 建立一对多的关系，一个用户可以有多个回答的评论
    user=db.relationship('User',backref=db.backref('answer_comment_list',lazy='dynamic'))
    # 一个问题可以有很多个回答的评论
    question=db.relationship('Question',backref=db.backref('question_comment_list',lazy='dynamic'))
    # 一个回答可以有很多个评论
    answer = db.relationship('Answer', backref=db.backref('answer_comment_list', lazy='dynamic'))


# 点赞回答
class AnswerLove(db.Model):
    __tablename__ = "qa_answer_love"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id')) # 管理
    q_id=db.Column(db.Integer,db.ForeignKey('qa_question.id'))  # 关联问题
    answer_id = db.Column(db.Integer, db.ForeignKey('qa_answer.id'))  # 关联回答
    created_at = db.Column(db.DateTime, default=datetime.now())
    # 建立一对多的关系，一个用户可以有多个回答的评论
    user=db.relationship('User',backref=db.backref('answer_love_list',lazy='dynamic'))
    # 一个问题可以有很多个回答的评论
    question=db.relationship('Question',backref=db.backref('answer_love_list',lazy='dynamic'))
    # 一个回答可以有很多个评论
    answer = db.relationship('Answer', backref=db.backref('answer_love_list', lazy='dynamic'))


# 收藏的回答
class AnswerCollect(db.Model):
    __tablename__ = "qa_answer_collect"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id')) # 管理
    q_id=db.Column(db.Integer,db.ForeignKey('qa_question.id'))  # 关联问题
    answer_id = db.Column(db.Integer, db.ForeignKey('qa_answer.id'))  # 关联回答
    is_valid=db.Column(db.Boolean,default=True)
    created_at = db.Column(db.DateTime, default=datetime.now())
    # 建立一对多的关系，一个用户可以有多个回答的评论
    user=db.relationship('User',backref=db.backref('answer_collect_list',lazy='dynamic'))
    # 一个问题可以有很多个回答的评论
    question=db.relationship('Question',backref=db.backref('answer_collect_list',lazy='dynamic'))
    # 一个回答可以有很多个评论
    answer = db.relationship('Answer', backref=db.backref('answer_collect_list', lazy='dynamic'))


# 关注的问题
class QuestionFollow(db.Model):
    __tablename__ = "qa_question_follow"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id')) # 管理
    q_id=db.Column(db.Integer,db.ForeignKey('qa_question.id'))  # 关联问题
    is_valid=db.Column(db.Boolean,default=True)
    created_at = db.Column(db.DateTime, default=datetime.now())
    # 建立一对多的关系，一个用户可以有多个回答的评论
    user=db.relationship('User',backref=db.backref('question_follow_list',lazy='dynamic'))
    # 一个问题可以有很多个回答的评论
    question=db.relationship('Question',backref=db.backref('question_follow_list',lazy='dynamic'))


# 问题的标签
class QuestionTags(db.Model):
    __tablename__ = "qa_question_tags"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    q_id=db.Column(db.Integer,db.ForeignKey('qa_question.id'))  # 关联问题
    tag_name=db.Column(db.VARCHAR(32),nullable=False)
    is_valid=db.Column(db.Boolean,default=True)
    created_at = db.Column(db.DateTime, default=datetime.now())
    # 一个问题可以有很多个回答的评论
    question=db.relationship('Question',backref=db.backref('question_tags_list',lazy='dynamic'))


# from sqlalchemy import create_engine
#
# engine = create_engine('mysql://root:1234@112.74.189.60:3310/flask_qa')
#
# # AnswerComment.__table__.drop(engine)
# Question.__table__.drop(engine)


